import org.junit.Test;

import javax.swing.*;
import java.util.HashMap;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.lang.Math;

public class Ms {
    private static int[] array=new int[]{1,2,3,4,5,6,2,1,1,4};
    static ExecutorService executorService= Executors.newSingleThreadExecutor();
    public static void main(String[] args) throws InterruptedException {

//        Thread thread1=new Thread(new Runnable() {
//            @Override
//            public void run() {
//                System.err.println("thread1");
//            }
//        });
//        Thread thread2=new Thread(new Runnable() {
//            @Override
//            public void run() {
//                System.err.println("thread2");
//            }
//        });
//        Thread thread3=new Thread(new Runnable() {
//            @Override
//            public void run() {
//                System.err.println("thread3");
//            }
//        });
//        executorService.submit(thread1);
//        executorService.submit(thread2);
//        executorService.submit(thread3);
//        executorService.shutdown();
       // new Ms().binaryToDecimal();
        new Ms().charToString();
       // System.err.println(new Ms().singleNumber(array));
        //System.err.println(new Ms().binaryToDecimal(56));


//        System.err.println(2>>1);//右移 逻辑右移：低位溢出，高位补0 10 01
//        System.err.println(2<<1);//左移 高位溢出，低位补0 10 010
//        System.err.println(2>>>1);//算术右移 高位溢出，低位补0 10 010
//        int[] array=new int[]{1,2,3,4,5};
//        System.err.println(new Ms().searchInsert(array, 6));6




        //twosum
        int[] nums={1,2,7,11,22};
        int target=9;
        for ( int array:new Ms().twoSum(nums, target)) {
            System.err.println(array);
        };
    }
//   private static Integer[] array=new Integer[]{1,2,3,4,5,6,2,1,1,4};
    //打印数组中不重复的值，或者重复的值
    @Test
    public void Array(){
        Integer[] array=new Integer[]{1,2,3,4,5,6,2,1,1,4};
        HashMap<Integer,Integer> hashMap=new HashMap<>();
        for (int i = 0; i <array.length ; i++) {
            if (hashMap.containsKey(array[i])){
                hashMap.put(array[i],hashMap.get(array[i])+1);
            }else {
                hashMap.put(array[i],1);
            }
        }

        for (Integer key:hashMap.keySet()) {
            if (hashMap.get(key)==1){
                //数组中不重复的值
                System.out.print(key);
            }else {
                //数组中重复的值
                System.err.println(key);
            }
        }
    }

    //在有序数组中搜索要插入的元素的位置
    //1.暴力破解,遍历的方式（暴力解法），时间复杂度为O(n)
    public int searchInsert1(int[] nums, int target){
        if (nums==null | nums.length==0){
            return -1;
        }
        for (int i = 0; i <nums.length ; i++) {
            if (nums[i]>=target){
                return i;
            }
        }
        return nums.length;
    }
    //2.利用二分法,采用二分查找法，时间复杂度为O(logn)
    public int searchInsert(int[] nums, int target) {
        if(nums == null){
            return -1;
        }
        int l = 0, r = nums.length-1;
        int m;
        while(l<=r){
            m = (l + r) >>> 1;
            if(nums[m] == target){
                return m;
            }else if(nums[m] < target){
                l = m + 1;
            }else{
                r = m - 1;
            }
        }
        return l;
    }

    //十进制转换为二进制
    public int zhuanghuang(){
        int num= 100;
        while (num%2==0){
//            num%2
        }
        return -1;
    }

    public int singleNumber(int[] nums) {
        HashMap<Integer,Integer> map=new HashMap<>();
        for (int i = 0; i <nums.length ; i++) {
            if (map.containsKey(nums[i])){
                map.put(nums[i],map.get(nums[i])+1);
            }else{
                map.put(nums[i],1);
            }
        }
        for (Integer key:map.keySet()) {
            if (map.get(key)==1){
                return key.intValue();
            }
        }
        return -1;
    }

    /**
     * 转换成二进制
     * @param n
     * @return
     */
    public String binaryToDecimal(int n){
        String str = "";
        while(n!=0){
            str = n%2+str;
            n = n/2;
        }
//        System.out.println(str);
       return str;
    }

    /**
     * 转换成十进制
     */
    public void binaryToDecimal() {
        Scanner s = new Scanner(System.in);

        System.out.println("Enter a binary number:");

        String n = s.nextLine();

        System.out.println(Integer.parseInt(n, 2));
        //return Integer.parseInt(n, 2);
    }

    /**
     * 把char数组转换为String
     */
    public void charToString(){
        char[] chars=new char[]{'a', 'b','c'};
        String str=String.valueOf(chars);
        System.err.println(str);
        char[] chars1=str.toCharArray();
        for (char s:chars1) {
            System.err.println(s);
        }
    }

    /**
     * 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。
     *
     * 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
     *
     * 来源：力扣（LeetCode）
     * 链接：https://leetcode-cn.com/problems/two-sum
     *
     */
    public int[] twoSum(int[] nums, int target) {
       int[] res=new int[2];
        for (int i = 0; i <nums.length ; i++) {
            for (int j =i+1; j <nums.length-1 ; j++) {
                if (nums[i]+nums[j]==target){
                    res[0]=i;
                    res[1]=j;
                    break;
                }

            }
        }
        return res;
    }

    /**
     * 求两个链表对应地址的和 leetcode-002
     * @param l1
     * @param l2
     * @return
     */
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode pre = new ListNode(0);
        ListNode cur = pre;
        int carry = 0;
        while(l1 != null || l2 != null) {
            int x = l1 == null ? 0 : l1.val;
            int y = l2 == null ? 0 : l2.val;
            int sum = x + y + carry;

            carry = sum / 10;
            sum = sum % 10;
            cur.next = new ListNode(sum);

            cur = cur.next;
            if(l1 != null)
                l1 = l1.next;
            if(l2 != null)
                l2 = l2.next;
        }
        if(carry == 1) {
            cur.next = new ListNode(carry);
        }
        return pre.next;
    }

    /**
     * 回文数
     * @param
     * @return
     */
    @Test
    public void isPalvoidindrome() {
        int x=12;
        if(x<0||(x!=0&&x%10==0)){
//            return false;
            System.err.println(false);
        }
        //将数字一分为二 为后半部分
        int n=0 ;
        while(x>n){
            n=n*10+x%10;
            x=x/10;
        }
//        return n==x||x==n/10;
         if(n==x||x==n/10){
             System.err.println(true);
         }


    }

    /**
     * 罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
     *
     * 字符          数值
     * I             1
     * V             5
     * X             10
     * L             50
     * C             100
     * D             500
     * M             1000
     * 例如， 罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。
     *
     * 通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
     *
     * I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
     * X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
     * C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
     * 给定一个罗马数字，将其转换成整数。
     *
     * 来源：力扣（LeetCode）
     * 链接：https://leetcode-cn.com/problems/roman-to-integer
     * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
     * @param s
     * @return
     */
    @Test
    public int romanToInt(String s) {
        //String s="MDCXCV";
        HashMap<String,Integer> hashmap=new HashMap();
        hashmap.put("I",1);
        hashmap.put("V",5);
        hashmap.put("X",10);
        hashmap.put("L",50);
        hashmap.put("C",100);
        hashmap.put("D",500);
        hashmap.put("M",1000);
        String[] Str=s.concat("I").split("");
        Integer result=0;
        for(int i=0;i<Str.length-1;i++){
            if(hashmap.get(Str[i])<hashmap.get(Str[i+1])){
                result+=hashmap.get(Str[i+1])-hashmap.get(Str[i]);
                i++;
            }else{
                result+=hashmap.get(Str[i]);
            }
        }

        return result;
    }

    }
